home *** CD-ROM | disk | FTP | other *** search
/ io Programmo 72 / IOPROG_72.ISO / soft / Codice / CRobots / Codice Robot anni precedenti / CR1-SRC.ZIP / CLOVER.R < prev    next >
Encoding:
Text File  |  1991-12-03  |  5.7 KB  |  311 lines
  1. /*
  2.  
  3.              >>> clover <<<
  4.  
  5.           crobot a quadrifoglio
  6.  
  7.     by Enrico Colombini, Novembre 1991
  8.  
  9. */
  10.  
  11.  
  12.  
  13. /* variabili: */
  14.  
  15. int    dir;                                            /*direzione corrente*/
  16. int    at, bt;                                            /*angoli bersagli*/
  17. int    dt;                                                /*distanza bersaglio*/
  18. int    deltas;                                            /*delta in scansione lato*/
  19. int    atmax;                                            /*angolo massimo per Lato*/
  20. int    ngiri, n, d;
  21.  
  22.  
  23.  
  24. /* --- sezione strategica ------------------------------------------------ */
  25.  
  26.  
  27. main()
  28. {
  29.     if ((n = rand(4)) == 0) {                       /*estrae lato iniziale*/
  30.         Nord(940);                                    /*si posiziona*/
  31.         if (loc_x() > 600) { 
  32.             Ovest(400); 
  33.         }
  34.     } else if (n == 1) {
  35.         Ovest(60);
  36.         if (loc_y() > 600) { 
  37.             Sud(400); 
  38.         }
  39.         LatoOvest();
  40.         LatoSud();
  41.         LatoEst();
  42.     } else if (n == 2) {
  43.         Sud(60);
  44.         if (loc_x() < 400) { 
  45.             Est(600); 
  46.         }
  47.         LatoSud();
  48.         LatoEst();
  49.     } else {
  50.         Est(940);
  51.         if (loc_y() < 600) { 
  52.             Nord(600); 
  53.         }
  54.         LatoEst();
  55.     }
  56.  
  57.     while (1) {                                        /*ciclo principale*/
  58.         LatoNord();
  59.         LatoOvest();
  60.         LatoSud();
  61.         LatoEst();
  62.     }
  63. }
  64.  
  65.  
  66. /* LatoNord: fa il lato nord per n volte, salvo danni, poi passa ad ovest */
  67.  
  68. LatoNord()
  69. {
  70.     n = 3; 
  71.     d = damage();
  72.     Est(800);
  73.     while (damage() - d < 16 && --n) { 
  74.         Ovest(200); 
  75.         Est(800); 
  76.     }
  77.     Vai(225);
  78.     while (loc_x() > 50 && speed()) { 
  79.         Diag(); 
  80.     }
  81. }
  82.  
  83.  
  84. /* LatoOvest: fa il lato ovest per n volte, salvo danni, poi passa a sud */
  85.  
  86. LatoOvest()
  87. {
  88.     n = 3; 
  89.     d = damage();
  90.     Nord(800);
  91.     while (damage() - d < 16 && --n) { 
  92.         Sud(200); 
  93.         Nord(800); 
  94.     }
  95.     Vai(315);
  96.     while (loc_y() > 50 && speed()) { 
  97.         Diag(); 
  98.     }
  99. }
  100.  
  101.  
  102. /* LatoSud: fa il lato sud per n volte, salvo danni, poi passa ad est */
  103.  
  104. LatoSud()
  105. {
  106.     n = 3; 
  107.     d = damage();
  108.     Ovest(200);
  109.     while (damage() - d < 16 && --n) { 
  110.         Est(800); 
  111.         Ovest(200); 
  112.     }
  113.     Vai(45);
  114.     while (loc_x() < 950 && speed()) { 
  115.         Diag(); 
  116.     }
  117. }
  118.  
  119.  
  120. /* LatoEst: fa il lato est per n volte, salvo danni, poi passa a nord */
  121.  
  122. LatoEst()
  123. {
  124.     n = 3; 
  125.     d = damage();
  126.     Sud(200);
  127.     while (damage() - d < 16 && --n) { 
  128.         Nord(800); 
  129.         Sud(200); 
  130.     }
  131.     Vai(135);
  132.     while (loc_y() < 950 && speed()) { 
  133.         Diag(); 
  134.     }
  135. }
  136.  
  137.  
  138.  
  139. /* --- sezione tattica --------------------------------------------------- */
  140.  
  141.  
  142. /* Vai: si gira nella direzione indicata */
  143.  
  144. Vai(d)
  145. {
  146.     drive(d, 0);                                        /*spegne il motore*/
  147.     while (speed() > 50) {
  148.     }                            /*aspetta di poter girare*/
  149.     drive(d, 100);                                    /*riparte a tutta birra*/
  150.     at = bt = d + 360;                                /*prepara scansione*/
  151.     atmax = at + 10;
  152. }
  153.  
  154.  
  155. /* Nord: va a nord fino alla y data */
  156.  
  157. Nord(y)
  158. int    y;
  159. {
  160.     Vai(90);
  161.     if (scan(90, 10) || scan(270, 10)) {                /*sceglie routine*/
  162.         while (loc_y() < y && speed()) { 
  163.             Lato(); 
  164.         }
  165.     } else {
  166.         while (loc_y() < y && speed()) {
  167.             if (dt = scan(at, 8)) {                  /*scan verso destra*/
  168.                 cannon(at, dt);
  169.             } else {                                /*non trovato, avanza*/
  170.                 at -= 14;
  171.             }
  172.             if (dt = scan(bt, 8)) {                  /*scan verso sinistra*/
  173.                 cannon(bt, dt);
  174.             } else {                                /*non trovato, avanza*/
  175.                 bt += 14;
  176.             }
  177.         }
  178.     }
  179. }
  180.  
  181.  
  182. /* Sud: va a sud fino alla y data */
  183.  
  184. Sud(y)
  185. int    y;
  186. {
  187.     Vai(270);
  188.     if (scan(270, 10) || scan(90, 10)) {
  189.         while (loc_y() > y && speed()) { 
  190.             Lato(); 
  191.         }
  192.     } else {
  193.         while (loc_y() > y && speed()) {
  194.             if (dt = scan(at, 8)) {
  195.                 cannon(at, dt);
  196.             } else {
  197.                 at -= 14;
  198.             }
  199.             if (dt = scan(bt, 8)) {
  200.                 cannon(bt, dt);
  201.             } else {
  202.                 bt += 14;
  203.             }
  204.         }
  205.     }
  206. }
  207.  
  208.  
  209. /* Est: va ad est fino alla x data */
  210.  
  211. Est(x)
  212. int    x;
  213. {
  214.     Vai(0);
  215.     if (scan(0, 10) || scan(180, 10)) {
  216.         while (loc_x() < x && speed()) { 
  217.             Lato(); 
  218.         }
  219.     } else {
  220.         while (loc_x() < x && speed()) {
  221.             if (dt = scan(at, 8)) {
  222.                 cannon(at, dt);
  223.             } else {
  224.                 at -= 14;
  225.             }
  226.             if (dt = scan(bt, 8)) {
  227.                 cannon(bt, dt);
  228.             } else {
  229.                 bt += 14;
  230.             }
  231.         }
  232.     }
  233. }
  234.  
  235.  
  236. /* Ovest: va ad ovest fino alla x data */
  237.  
  238. Ovest(x)
  239. int    x;
  240. {
  241.     Vai(180);
  242.     if (scan(180, 10) || scan(0, 10)) {
  243.         while (loc_x() > x && speed()) { 
  244.             Lato(); 
  245.         }
  246.     } else {
  247.         while (loc_x() > x && speed()) {
  248.             if (dt = scan(at, 8)) {
  249.                 cannon(at, dt);
  250.             } else {
  251.                 at -= 14;
  252.             }
  253.             if (dt = scan(bt, 8)) {
  254.                 cannon(bt, dt);
  255.             } else {
  256.                 bt += 14;
  257.             }
  258.         }
  259.     }
  260. }
  261.  
  262.  
  263. /* Diag: movimento diagonale o generico, cerca bersaglio sui due lati */
  264.  
  265. Diag()
  266. {
  267.     dt = scan(at, 8);
  268.     if (dt && dt < 500) {                              /*scan verso destra*/
  269.         cannon(at, dt);
  270.     } else {                                           /*non trovato, avanza*/
  271.         at -= 14;
  272.     }
  273.     dt = scan(bt, 8);
  274.     if (dt && dt < 500) {                             /*scan verso sinistra*/
  275.         cannon(bt, dt);
  276.     } else {                                           /*non trovato, avanza*/
  277.         bt += 14;
  278.     }
  279. }
  280.  
  281.  
  282. /* Lato: spara con mira accurata ai robot che si muovono sullo stesso lato */
  283.  
  284. Lato()
  285. {
  286.     dt = scan(at, 3);
  287.     if (dt) {                                        /*se vede qualcuno davanti*/
  288.         deltas = scan(at, 10) - dt;                     /*valuta movimento*/
  289.         cannon(at, (500 * dt) / (440 - deltas * 14));        /*spara dove lo prevede*/
  290.     } else {
  291.         dt = scan((bt = at + 180), 3);                       /*idem all'indietro*/
  292.         if (dt) {
  293.             deltas = scan(bt, 10) - dt;
  294.             cannon(bt, (500 * dt) / (560 - deltas * 14));
  295.         } else {                                    /*bersaglio non trovato*/
  296.             if ((at += 5) > atmax) { 
  297.                 at -= 25; 
  298.             }      /*prepara nuova scansione*/
  299.         }
  300.     }
  301. }
  302.  
  303.  
  304. /* Note:
  305.     14 = fattore di velocita' bersaglio (per v = 100, deltas = 7)
  306.     deltas*14 = velocita' assoluta bersaglio
  307.     500 = velocita' assoluta proiettile
  308.     500-(deltas*14) = velocita' proiettile relativa al bersaglio
  309.     440,460: compensazioni empiriche per tempo trascorso e varie
  310. */
  311.